Gregorianske kalender

Den gregorianske kalender er den almindelige danske kalender som vi bruger til at holde styr på hvilken dato det er i løbet af året.

At lave en kalender der præcis dækker et år, giver lidt problemer, da det "tropiske år" er ikke på 365 døgn, men på 365,24219878 døgn. Da den overskydende del siden oldtiden har været erkendt til at være et kvart døgn, indførte Julius Cæsar, efter forslag af grækeren Sosigenes, i år 46 f.Kr. den julianske kalender. Ifølge den julianske kalender skulle år delelig med fire være skudår, det vil sige indeholde 366 dage i stedet for normalt 365 dage. Det julianske år har derfor længden 365,25 dage.

Årslængden på 365,25 dage gjorde dog at der i 1500 tallet var kommet en afvigelse på ca. 12-13 døgn, så i 1582 indførte Pave Gregor d. 13. den gregorianske kalender. Samtidig med inførelsen af denne kalender blev datoen rettet med cirka 14 dage.

Den gregorianske kalender har, ligesom den julianske, skudår hvert fjerde år, men til gengæld er år delelige med 100 ikke skudår, undtagen år der er delelig med 400, som er skudår. Dette giver en årslængde på i snit 365,32425 dage, meget tæt på det ønskede. Denne kalender giver kun en fejl på cirka 3 dage på 10000 år. Så er man perfektionist, så burde år delelig med 4000 ikke være skudår.

Den gregorianske kalender blev desvære indført af paven lige efter Luther og reformationen, så mange protestantiske fyrstedømmer og lande indførte først den nye kalender meget senere. I Danmark blev den gregorianske kalender indført i marts 1700. (Samtidig med at der skete et spring i datoen på 11 dage). Den russisk ortodokse kirke benytter stadig den gamle julianske kalender, og det er derfor de fejrer jul omtrent på samme tidspunkt som vi fejrer Hellig Tre Konger.

Skal man til at beregne ugedag, eller antal dage mellem to datoer, vil en algoritme derfor kun give fornuftige data, såfremt man tager hensyn til hvilket land det drejer sig om, og datoen for den gregorianske kalenders indførelse, samt hvilken dato man foretog justeringen.

Se gregorianske kalender (algoritme), for en uddybende gennemgang af en algoritme til beregning af ugedage og datoer.

Gregorianske kalender (algoritme)

Skal man til at beregne ugedag, eller antal dage mellem to datoer i den gregorianske kalender, vil en algoritme kun give fornuftige data, såfremt man tager hensyn til hvilket land det drejer sig om, og datoen for den gregorianske kalenders indførelse, samt hvilken dato man foretog justeringen.

Opbygning af algoritmen

Det første man opdager ved at se på kalenderen er at den er opbygget af år, måneder, og dage, hvor der ikke umiddelbart ser ud til at være nogen pæn lineær sammenhæng. Et brute-force kodet program til ugedags beregning vil derfor kunne komme til at bestå af mange "if/case" kontruktioner til at tage højde for de forskellige regler.

For at undgå dette indser man at der må laves en anden skala, f.eks. antal dage siden et "fiktiv" år 0. Dette er meget nemmere at udregne, idet reglerne i den gregorianske kalender er meget klare. Så antallet af dage fra år 0 til den 0. januar kan så beregnes på følgende måde:

10/ der benyttes heltals divison ! /

Faktor = 365ÅR + (ÅR-1)/4 - (ÅR-1)/100 + (ÅR-1)/400 ;

Forkortes lidt fås:

10Faktor = 365ÅR + (ÅR-1)/4 - ((ÅR-1)/100)3/4 ;

Næste problem bliver februar, som kan være på enten 28 eller 29 dage. Alle andre måneder har et fast antal dage. Det nemmeste er at flytte årets start til marts, idet februar så kommer sidst, så behøves der ikke at tages hensyn til om det er skudår eller ej, når den aktuelle "faktor" skal udregnes for en given dato. Nu mangler der så kun, at få lavet en linær sammenhæng mellem dag i året og aktuel måned og dag. Hvis man starter med at tælle fra marts får man følgende tabel:

10Måned Antal dage Dag i året-

Marts 31 0

April 30 31

Maj 31 61

Juni 30 92

Juli 31 122

August 31 153

September 30 184

Oktober 31 214

November 30 245

December 31 275

Januar 31 306

Februar 28/29 337

I alt 365/366

Nu kunne en sådan tabel løsning være ideel, og de fleste ville nok kunne stille sig tilfreds her. Algoritmen ville komme til at se ud som følgende:

10/ der benyttes heltals divison ! /

if (Måned < 3 ) {

/ da skuddagen er den 29/2, skal skuddag ikke medregnes i jan/feb /

/ så derfor benyttes ÅR-1 /

Faktor = 365ÅR + (ÅR-1)/4 - (((ÅR-1)/100)3)/4 + tabel[Måned] + Dag.

} else {

Faktor = 365ÅR + ÅR/4 - ((ÅR/100)3)/4 + tabel[Måned] + Dag.

} Tabellen kan forenkles noget. Plotter man tabellen ind på millimeterpapir, og gives Januar og Februar hhv. månedsnummeret 13 og 14, vil man opdage, at man (næsten) kan tegne en ret linje i gennem de plottede punkter. Ved enten af aflæse, eller ved at benytte lineær regression, kan man få hældningskoefficient (m) og skæring med Y-aksen (b):

10m = 30,6013986 , b = -91,77855478 .

Ved beregningen fremkom korrelationskoefficienten 0,999996, som er ganske godt, da 1,00 ville være fuldkommen korrelation. Tabellen fra før kan derfor erstattes med:

10round ( Måned30,60 - 91,78 )

= Int ( Måned30,60 - 91,78 + 0,5 )

= Int ( Måned30,60 - 91,28 )

For ikke at skulle benytte reelle tal (float), udregnes det hele i en heltal udgave, og samtidig forenkles beregningen ved Januar og Februar. Den færdige rutine bliver så:

10/ ------------------- factor -----------------------------/

\#define LONGWORD unsigned int

LONGWORD factor(RTCtime tm)

{

WORD y,m;

y = tm->year;

m = tm->month;

if ( tm->month < 3 ) { y--; m +='12;' }

return 365ULy + y/4UL - ((y/100+1)3)/4 + (m3060-9135)/100 + tm->day + 59;

}

Datastrukturen for RTCtime er lavet for at holde lidt styr på dag, måned og år.

Beregning af ugedag

Der er 7 dage i en uge, og dagene gentager sig hele tiden, så beregning af ugedag kan nemt gøres ved modulus 7. Ønskes derudover at søndag er ugedag nr. 0, skal der først adderes 6 til faktoren.

/------------------- weekday ------------------------------/

/ returns weekday, sun=0, mon=1,..... : /

int weekday(RTCtime tm)

{

return (int) ( (factor(tm)+6) % 7UL );

}

Beregning af antal dage m